/* Copyright (C) 2013 IP Infusion, Inc. All Rights Reserved. */

#include <bgp_incl.h>

/* Lookup master structure for community-list or extcommunity-list */
struct community_list_master *
community_list_master_lookup (struct community_list_handler *ch,
                              enum community_list_type style)
{
  if (ch)
    switch (style)
      {
      case COMMUNITY_LIST_STANDARD:
      case COMMUNITY_LIST_EXPANDED:
      case COMMUNITY_LIST_AUTO:
        return &ch->community_list;
        break;
      case EXTCOMMUNITY_LIST_STANDARD:
      case EXTCOMMUNITY_LIST_EXPANDED:
      case EXTCOMMUNITY_LIST_AUTO:
        return &ch->extcommunity_list;
      }
  return NULL;
}

/* Allocate a new community list entry */
struct community_entry *
community_entry_new ()
{
  struct community_entry *new;

  new = XCALLOC (MTYPE_COMMUNITY_LIST_ENTRY, sizeof (struct community_entry));

  return new;
}

/* Free community list entry */
void
community_entry_free (struct community_entry *entry)
{
  switch (entry->style)
    {
    case COMMUNITY_LIST_STANDARD:
      if (entry->u.com)
        community_free (entry->u.com);
      break;
    case EXTCOMMUNITY_LIST_STANDARD:
      /* In case of standard extcommunity-list, configuration string
         is made by ecommunity_ecom2str().  */
      if (entry->config)
        XFREE (MTYPE_ECOMMUNITY_STR, entry->config);
      if (entry->u.ecom)
        ecommunity_free (entry->u.ecom);
      break;
    case COMMUNITY_LIST_EXPANDED:
    case EXTCOMMUNITY_LIST_EXPANDED:
      if (entry->config)
        XFREE (MTYPE_COMMUNITY_LIST_CONFIG, entry->config);
      if (entry->reg)
        bgp_regex_free (entry->reg);
    default:
      break;
    }
  XFREE (MTYPE_COMMUNITY_LIST_ENTRY, entry);
}

/* Allocate a new community-list */
struct community_list *
community_list_new ()
{
  struct community_list *new;

  new = XCALLOC (MTYPE_COMMUNITY_LIST, sizeof (struct community_list));

  return new;
}

/* Free community-list */
void
community_list_free (struct community_list *list)
{
  if (list->name)
    XFREE (MTYPE_COMMUNITY_LIST_NAME, list->name);
  XFREE (MTYPE_COMMUNITY_LIST, list);
}

struct community_list *
community_list_insert (struct community_list_handler *ch,
                       u_int8_t *name,
                       enum community_list_type style)
{
  int i;
  s_int32_t number;
  struct community_list *new;
  struct community_list *point;
  struct community_list_list *list;
  struct community_list_master *cm;

  /* Lookup community-list master.  */
  cm = community_list_master_lookup (ch, style);
  if (! cm)
    return NULL;

  /* Allocate new community_list and copy given name. */
  new = community_list_new ();
  new->name = XSTRDUP (MTYPE_COMMUNITY_LIST_NAME, name);

  /* If name is made by all digit character.  We treat it as
     number. */
  for (number = 0, i = 0; i < pal_strlen (name); i++)
    {
      if (pal_char_isdigit ((int) name[i]))
        number = (number * 10) + (name[i] - '0');
      else
        break;
    }

  /* In case of name is all digit character */
  if (i == pal_strlen (name))
    {
      new->sort = COMMUNITY_LIST_NUMBER;

      /* Set access_list to number list. */
      list = &cm->num;

      for (point = list->head; point; point = point->next)
        if (pal_strtos32 (point->name, (char **)NULL, 10) >= number)
          break;
    }
  else
    {
      new->sort = COMMUNITY_LIST_STRING;

      /* Set access_list to string list. */
      list = &cm->str;

      /* Set point to insertion point. */
      for (point = list->head; point; point = point->next)
        if (pal_strcmp (point->name, name) >= 0)
          break;
    }

  /* Link to upper list.  */
  new->parent = list;

  /* In case of this is the first element of master. */
  if (list->head == NULL)
    {
      list->head = list->tail = new;
      return new;
    }

  /* In case of insertion is made at the tail of access_list. */
  if (point == NULL)
    {
      new->prev = list->tail;
      list->tail->next = new;
      list->tail = new;
      return new;
    }

  /* In case of insertion is made at the head of access_list. */
  if (point == list->head)
    {
      new->next = list->head;
      list->head->prev = new;
      list->head = new;
      return new;
    }

  /* Insertion is made at middle of the access_list. */
  new->next = point;
  new->prev = point->prev;

  if (point->prev)
    point->prev->next = new;
  point->prev = new;

  return new;
}

struct community_list *
community_list_lookup (struct community_list_handler *ch,
                       u_int8_t *name,
                       enum community_list_type style)
{
  struct community_list *list;
  struct community_list_master *cm;

  if (! name)
    return NULL;

  cm = community_list_master_lookup (ch, style);
  if (! cm)
    return NULL;

  for (list = cm->num.head; list; list = list->next)
    if (pal_strcmp (list->name, name) == 0)
      return list;
  for (list = cm->str.head; list; list = list->next)
    if (pal_strcmp (list->name, name) == 0)
      return list;

  return NULL;
}

struct community_list *
community_list_get (struct community_list_handler *ch,
                    u_int8_t *name,
                    enum community_list_type style)
{
  struct community_list *list;

  list = community_list_lookup (ch, name, style);
  if (! list)
    list = community_list_insert (ch, name, style);
  return list;
}

void
community_list_delete (struct community_list *list)
{
  struct community_list_list *clist;
  struct community_entry *entry, *next;

  for (entry = list->head; entry; entry = next)
    {
      next = entry->next;
      community_entry_free (entry);
    }

  clist = list->parent;

  if (list->next)
    list->next->prev = list->prev;
  else
    clist->tail = list->prev;

  if (list->prev)
    list->prev->next = list->next;
  else
    clist->head = list->next;

  community_list_free (list);
}

int
community_list_empty_p (struct community_list *list)
{
  return (list->head == NULL && list->tail == NULL) ? 1 : 0;
}

/* Add community-list entry to the list */
static void
community_list_entry_add (struct community_list *list,
                          struct community_entry *entry)
{
  entry->next = NULL;
  entry->prev = list->tail;

  if (list->tail)
    list->tail->next = entry;
  else
    list->head = entry;
  list->tail = entry;
}

/* Delete community-list entry from the list */
static void
community_list_entry_delete (struct community_list *list,
                             struct community_entry *entry,
                             enum community_list_type style)
{
  if (entry->next)
    entry->next->prev = entry->prev;
  else
    list->tail = entry->prev;

  if (entry->prev)
    entry->prev->next = entry->next;
  else
    list->head = entry->next;

  community_entry_free (entry);

  if (community_list_empty_p (list))
    community_list_delete (list);
}

/* Lookup community-list entry from the list */
static struct community_entry *
community_list_entry_lookup (struct community_list *list,
                             void *arg,
                             enum community_type direct)
{
  struct community_entry *entry;

  for (entry = list->head; entry; entry = entry->next)
    {
      switch (entry->style)
        {
        case COMMUNITY_LIST_STANDARD:
          if ((entry->direct == direct) && community_cmp (entry->u.com, arg))
            return entry;
          break;
        case EXTCOMMUNITY_LIST_STANDARD:
          if ((entry->direct == direct) && ecommunity_cmp (entry->u.ecom, arg))
            return entry;
          break;
        case COMMUNITY_LIST_EXPANDED:
        case EXTCOMMUNITY_LIST_EXPANDED:
          if ((entry->direct == direct) && pal_strcmp (entry->config, arg) == 0)
            return entry;
          break;
        default:
          break;
        }
    }
  return NULL;
}

/* Internal function to perform regular expression match for community
   attribute.  */
static int
community_regexp_match (struct community *com, pal_regex_t *reg)
{
  u_int8_t *str;

  /* When there is no communities attribute it is treated as empty
     string.  */
  if (com == NULL || com->size == 0)
    str = "";
  else
    str = community_str (com);

  /* Regular expression match.  */
  if (pal_regexec (reg, str, 0, NULL, 0) == 0)
    return 1;

  /* No match.  */
  return 0;
}

/* Do regular expression matching with single community val */
static int
comval_regexp_match (u_int32_t comval, pal_regex_t *reg)
{
  /* Maximum is "65535:65535" + '\0'. */
  u_int8_t c [20];
  u_int8_t *str;

  switch (comval)
    {
    case COMMUNITY_INTERNET:
      str = "internet";
      break;
    case COMMUNITY_NO_EXPORT:
      str = "no-export";
      break;
    case COMMUNITY_NO_ADVERTISE:
      str = "no-advertise";
      break;
    case COMMUNITY_LOCAL_AS:
      str = "local-AS";
      break;
    default:
      pal_snprintf (c, sizeof c,
                    "%d:%d", (comval >> 16) & 0xFFFF, comval & 0xFFFF);
      str = c;
      break;
    }

  if (pal_regexec (reg, str, 0, NULL, 0) == 0)
    return 1;

  return 0;
}

/* Match community to any value in community-list */
enum community_type
community_list_match (struct community *com,
                      struct community_list *list)
{
  struct community_entry *entry;

  if (! list)
    return COMMUNITY_NO_MATCH;

  for (entry = list->head; entry; entry = entry->next)
    {
      if (entry->any)
        return entry->direct;

      if (entry->style == COMMUNITY_LIST_STANDARD)
        {
          if (community_include (entry->u.com, COMMUNITY_INTERNET))
            return entry->direct;

          if (community_match (com, entry->u.com))
            return entry->direct;
        }
      else if (entry->style == COMMUNITY_LIST_EXPANDED)
        {
          if (community_regexp_match (com, entry->reg))
            return entry->direct;
        }
    }

  return COMMUNITY_NO_MATCH;
}

/* Perform exact match */
enum community_type
community_list_exact_match (struct community *com,
                            struct community_list *list)
{
  struct community_entry *entry;

  if (! list)
    return COMMUNITY_NO_MATCH;

  for (entry = list->head; entry; entry = entry->next)
    {
      if (entry->any)
        return entry->direct;

      if (entry->style == COMMUNITY_LIST_STANDARD)
        {
          if (community_include (entry->u.com, COMMUNITY_INTERNET))
            return entry->direct;

          if (community_cmp (com, entry->u.com))
            return entry->direct;
        }
      else if (entry->style == COMMUNITY_LIST_EXPANDED)
        {
          if (community_regexp_match (com, entry->reg))
            return entry->direct;
        }
    }

  return COMMUNITY_NO_MATCH;
}

/* Delete all permitted communities in the list from com */
struct community *
community_list_match_delete (struct community *com,
                             struct community_list *clist)
{
  int i;
  u_int32_t comval;
  struct community *merge = NULL;
  struct community_entry *entry = NULL;

  /* Empty community value check.  */
  if (! com)
    return NULL;

  /* Duplicate communities value.  */
  merge = community_dup (com);
  if (merge == NULL)
    return NULL;

  /* For each communities value, we have to check each
     community-list.  */
  for (i = 0; i < com->size; i ++)
    {
      /* Get one communities value.  */
      pal_mem_cpy (&comval, com_nthval (com, i), sizeof (u_int32_t));
      comval = pal_ntoh32 (comval);

      /* Loop community-list.  */
      for (entry = clist->head; entry; entry = entry->next)
        {
          /* Various match condition check.  */
          if (entry->any
              || (entry->style == COMMUNITY_LIST_STANDARD
                  && entry->u.com
                  && community_include (entry->u.com, comval))
              || (entry->style == COMMUNITY_LIST_EXPANDED
                  && entry->reg
                  && comval_regexp_match (comval, entry->reg)))
            {
              /* If the rule is "permit", delete this community value. */
              if (entry->direct == COMMUNITY_PERMIT)
                community_del_val (merge, com_nthval (com, i));

              /* Exit community-list loop, goto next communities
                 value.  */
              break;
            }
        }
    }
  return merge;
}

/* To avoid duplicated entry in the community-list, this function
   compares specified entry to existing entry.  */
s_int32_t
community_list_dup_check (struct community_list *list,
                          struct community_entry *new)
{
  struct community_entry *entry;

  for (entry = list->head; entry; entry = entry->next)
    {
      if (entry->style != new->style)
        continue;

      if (entry->direct != new->direct)
        continue;

      if (entry->any != new->any)
        continue;

      if (entry->any)
        return 1;

      switch (entry->style)
        {
        case COMMUNITY_LIST_STANDARD:
          if (community_cmp (entry->u.com, new->u.com))
            return 1;
          break;
        case EXTCOMMUNITY_LIST_STANDARD:
          if (ecommunity_cmp (entry->u.ecom, new->u.ecom))
            return 1;
          break;
        case COMMUNITY_LIST_EXPANDED:
        case EXTCOMMUNITY_LIST_EXPANDED:
          if (pal_strcmp (entry->config, new->config) == 0)
            return 1;
          break;
        default:
          break;
        }
    }
  return 0;
}

/* Set community-list */
s_int32_t
community_list_set (struct community_list_handler *ch,
                    u_int8_t *name,
                    u_int8_t *str,
                    enum community_type direct,
                    enum community_list_type style)
{
  struct community_entry *entry;
  struct community_list *list;
  struct community *com;
  pal_regex_t *regex;

  entry = NULL;

  /* Get community list. */
  list = community_list_get (ch, name, style);
  if (list == NULL)
    return BGP_API_SET_ERROR;

  /* When community-list already has entry, new entry should have same
     style.  If you want to have mixed style community-list, you can
     comment out this check.  */
  if (! community_list_empty_p (list))
    {
      struct community_entry *first;

      first = list->head;

      if (style == COMMUNITY_LIST_AUTO)
        style = first->style;
      else if (style != first->style)
        return BGP_API_SET_ERR_CLIST_DEFINE_CONFLICT;
    }

  /* When str is NULL, it is matches any.  */
  if (! str)
    {
      entry = community_entry_new ();
      if (entry == NULL)
        return BGP_API_SET_ERROR;

      entry->direct = direct;
      entry->any = 1;
      if (style == COMMUNITY_LIST_AUTO)
        entry->style = COMMUNITY_LIST_STANDARD;
      else
        entry->style = style;
    }
  else
    {
      /* Standard community-list parse.  String must be converted into
         community structure without problem.  */
      if (style == COMMUNITY_LIST_STANDARD || style == COMMUNITY_LIST_AUTO)
        {
          com = community_str2com (str);
          if (com)
            {
              entry = community_entry_new ();
              if (entry == NULL)
                return BGP_API_SET_ERROR;

              entry->u.com = com;
              entry->direct = direct;
              entry->style = COMMUNITY_LIST_STANDARD;
            }
          else if ((style == COMMUNITY_LIST_STANDARD)||(style == COMMUNITY_LIST_AUTO))
            return BGP_API_SET_ERR_MALFORMED_ARG;

          /* We can't convert string into communities value.  When
             community-list type is auto, fall dawn to regular expression
             match.  */
        }

      /* Expanded community-list parse.  String may include regular
         expression.  */
      if (! entry && (style == COMMUNITY_LIST_EXPANDED
                      || style == COMMUNITY_LIST_AUTO))
        {
          regex = bgp_regcomp (str);
          if (regex)
            {
              entry = community_entry_new ();
              if (entry == NULL)
                return BGP_API_SET_ERROR;

              entry->reg = regex;
              entry->config = XSTRDUP (MTYPE_COMMUNITY_LIST_CONFIG, str);
              entry->direct = direct;
              entry->style = COMMUNITY_LIST_EXPANDED;
            }
          else
            return BGP_API_SET_ERR_MALFORMED_ARG;
        }
    }
  if (!entry)
    return BGP_API_SET_ERROR;

  /* Do not put duplicated community entry.  */
  if (community_list_dup_check (list, entry))
    community_entry_free (entry);
  else
    community_list_entry_add (list, entry);

  return 0;
}

/* Unset community-list.  When str is NULL, delete all of
   community-list entry belongs to the specified name.  */
s_int32_t
community_list_unset (struct community_list_handler *ch,
                      u_int8_t *name,
                      u_int8_t *str,
                      enum community_type direct,
                      enum community_list_type style)
{
  struct community_entry *entry;
  struct community_list *list;
  struct community *com;
  pal_regex_t *regex;

  entry = NULL;

  /* Lookup community list.  */
  list = community_list_lookup (ch, name, style);
  if (list == NULL)
    return BGP_API_SET_ERR_UNKNOWN_OBJECT;

  /* Delete all of entry belongs to this community-list.  */
  if (! str)
    {
      community_list_delete (list);
      return BGP_API_SET_SUCCESS;
    }

  /* Community list string is specified.  Lookup entry from community
     list.  */
  if (style == COMMUNITY_LIST_STANDARD || style == COMMUNITY_LIST_AUTO)
    {
      com = community_str2com (str);
      if (com)
        {
          entry = community_list_entry_lookup (list, com, direct);
          community_free (com);
        }
      else if (style == COMMUNITY_LIST_STANDARD)
        return BGP_API_SET_ERR_MALFORMED_ARG;

      /* If we can't convert string into community and community-list
         type is auto, fall dawn to expanded community-list.  */
    }

  /* Expanded community-list parse. String may include regular expression */
  if (! entry
      && (style == COMMUNITY_LIST_EXPANDED
          || style == COMMUNITY_LIST_AUTO))
    {
      regex = bgp_regcomp (str);
      if (regex)
        {
          entry = community_list_entry_lookup (list, str, direct);
          bgp_regex_free (regex);
        }
      else
        return BGP_API_SET_ERR_MALFORMED_ARG;
    }

  if (! entry)
    return BGP_API_SET_ERR_UNKNOWN_OBJECT;

  community_list_entry_delete (list, entry, style);

  return BGP_API_SET_SUCCESS;
}

/* Set extcommunity-list */
s_int32_t
extcommunity_list_set (struct community_list_handler *ch,
                       u_int8_t *name,
                       u_int8_t *str,
                       enum community_type direct,
                       enum community_list_type style)
{
  struct community_entry *entry;
  struct community_list *list;
  struct ecommunity *ecom;
  pal_regex_t *regex;

  entry = NULL;

  /* Get community list. */
  list = community_list_get (ch, name, style);
  if (list == NULL)
    return BGP_API_SET_ERROR;

  /* When community-list already has entry, new entry should have same
     style.  If you want to have mixed style community-list, you can
     comment out this check.  */
  if (! community_list_empty_p (list))
    {
      struct community_entry *first;

      first = list->head;

      if (style == EXTCOMMUNITY_LIST_AUTO)
        style = first->style;
      else if (style != first->style)
        return BGP_API_SET_ERR_CLIST_DEFINE_CONFLICT;
    }

  /* When str is NULL, it is matches any.  */
  if (! str)
    {
      entry = community_entry_new ();
      if (entry == NULL)
        return BGP_API_SET_ERROR;

      entry->direct = direct;
      entry->any = 1;
      if (style == EXTCOMMUNITY_LIST_AUTO)
        entry->style = EXTCOMMUNITY_LIST_STANDARD;
      else
        entry->style = style;
    }
  else
    {
      /* Standard extcommunity-list parse.  String is converted into
         ecommunity structure.  */
      if (style == EXTCOMMUNITY_LIST_STANDARD
          || style == EXTCOMMUNITY_LIST_AUTO)
        {
          /* Type is unknown.  String includes keyword.  */
          ecom = ecommunity_str2com (str, 0, 1);
          if (ecom)
            {
              entry = community_entry_new ();
              if (entry == NULL)
                return BGP_API_SET_ERROR;

              entry->config
                = ecommunity_ecom2str (ecom, ECOMMUNITY_FORMAT_COMMUNITY_LIST);
              ecom->str = ecommunity_ecom2str (ecom, ECOMMUNITY_FORMAT_DISPLAY);
              entry->u.ecom = ecom;
              entry->direct = direct;
              entry->style = EXTCOMMUNITY_LIST_STANDARD;
            }
          else if (style == EXTCOMMUNITY_LIST_STANDARD)
            return BGP_API_SET_ERR_MALFORMED_ARG;

          /* We can't convert string into communities value.  When
             community-list type is auto, fall dawn to regular expression
             match.  */
        }

      /* Expanded extcommunity-list parse.  String may include regular
         expression.  */
      if (! entry && (style == EXTCOMMUNITY_LIST_EXPANDED
                      || style == EXTCOMMUNITY_LIST_AUTO))
        {
          regex = bgp_regcomp (str);
          if (regex)
            {
              entry = community_entry_new ();
              if (entry == NULL)
                return BGP_API_SET_ERROR;

              entry->reg = regex;
              entry->config = XSTRDUP (MTYPE_COMMUNITY_LIST_CONFIG, str);
              entry->direct = direct;
              entry->style = EXTCOMMUNITY_LIST_EXPANDED;
            }
          else
            return BGP_API_SET_ERR_MALFORMED_ARG;
        }
    }

  if (!entry)
    return BGP_API_SET_ERROR;

  /* Do not put duplicated community entry.  */
  if (community_list_dup_check (list, entry))
    community_entry_free (entry);
  else
    community_list_entry_add (list, entry);

  return BGP_API_SET_SUCCESS;
}

/* Unset extcommunity-list.  When str is NULL, delete all of
   extcommunity-list entry belongs to the specified name.  */
s_int32_t
extcommunity_list_unset (struct community_list_handler *ch,
                         u_int8_t *name,
                         u_int8_t *str,
                         enum community_type direct,
                         enum community_list_type style)
{
  struct community_entry *entry;
  struct community_list *list;
  struct ecommunity *ecom;
  pal_regex_t *regex;

  entry = NULL;
  ecom = NULL;

  /* Lookup extcommunity list.  */
  list = community_list_lookup (ch, name, style);
  if (list == NULL)
    return BGP_API_SET_ERR_UNKNOWN_OBJECT;

  /* Delete all of entry belongs to this extcommunity-list.  */
  if (! str)
    {
      community_list_delete (list);
      return BGP_API_SET_SUCCESS;
    }

  /* Community list string is specified.  Lookup entry from community
     list.  */
  if (style == EXTCOMMUNITY_LIST_STANDARD || style == EXTCOMMUNITY_LIST_AUTO)
    {
      ecom = ecommunity_str2com (str, 0, 1);
      if (ecom)
        {
          entry = community_list_entry_lookup (list, ecom, direct);
          ecommunity_free (ecom);
        }
      else if (style == COMMUNITY_LIST_STANDARD)
        return BGP_API_SET_ERR_MALFORMED_ARG;

      /* If we can't convert string into community and community-list
         type is auto, fall dawn to expanded community-list.  */
    }

  /* Expanded community-list parse.  String may include regular
     expression.  */
  if (! entry
      && (style == EXTCOMMUNITY_LIST_EXPANDED || style == EXTCOMMUNITY_LIST_AUTO))
    {
      regex = bgp_regcomp (str);
      if (regex)
        {
          entry = community_list_entry_lookup (list, str, direct);
          bgp_regex_free (regex);
        }
      else
        return BGP_API_SET_ERR_MALFORMED_ARG;
    }

  if (! entry)
    return BGP_API_SET_ERR_UNKNOWN_OBJECT;

  community_list_entry_delete (list, entry, style);

  return BGP_API_SET_SUCCESS;
}

/* Initializa community-list.  Return community-list handler.  */
struct community_list_handler *
bgp_community_list_init (void)
{
  struct community_list_handler *ch;

  ch = XCALLOC (MTYPE_COMMUNITY_LIST_HANDLER,
                sizeof (struct community_list_handler));

  return ch;
}

/* Terminate community-list.  */
s_int32_t
bgp_community_list_terminate (struct community_list_handler *ch)
{
  struct community_list_master *cm;
  struct community_list *list;
  struct community_list *next;
  s_int32_t ret;

  ret = 0;

  if (! ch)
    {
      ret = -1;
      goto EXIT;
    }

  cm = &ch->community_list;
  for (list = cm->num.head; list; list = next)
    {
      next = list->next;
      community_list_delete (list);
    }
  for (list = cm->str.head; list; list = next)
    {
      next = list->next;
      community_list_delete (list);
    }

  cm = &ch->extcommunity_list;
  for (list = cm->num.head; list; list = next)
    {
      next = list->next;
      community_list_delete (list);
    }
  for (list = cm->str.head; list; list = next)
    {
      next = list->next;
      community_list_delete (list);
    }

  XFREE (MTYPE_COMMUNITY_LIST_HANDLER, ch);

EXIT:

  return ret;
}

/***************************************************************************
 * Function       : ecommunity_regexp_match                                *
 * Description    : This funcition will converts the given extended        * 
 *                  community in to string and perform regular expersion   * 
 *                  match.                                                 *
 * Input :                                                                 *
 *    ecom         : Extended community                                    *
 *    reg          : Regular expersion given by the operator.              *
 * output :                                                                *
 * community_type  : return permit or deny                                 *
 *                                                                         *  
 ***************************************************************************/

static int
ecommunity_regexp_match (struct ecommunity *ecom, pal_regex_t *reg)
{
  u_int8_t *str = NULL;

  /* When there is no communities attribute it is treated as empty
     string.  */
  if (ecom == NULL || ecom->size == 0)
    str = "";
  else
    str = ecommunity_str (ecom);

  /* Regular expression match.  */
  if (pal_regexec (reg, str, 0, NULL, 0) == 0)
    return 1;

  /* No match.  */
  return 0;
}

/***************************************************************************
 * Function       : ecommunity_list_extact_match                           *
 * Description    : This performs extact match if the match fail it        *
 *                  returns deny else permits the routes                   *
 * Input :                                                                 *
 *    ecom         : Extended community                                    *
 *    list         : community list                                        *
 * output :                                                                *
 * community_type  : return permit or deny                                 *
 *                                                                         *  
 ***************************************************************************/

enum community_type
ecommunity_list_exact_match (struct ecommunity *ecom,
                            struct community_list *list)
{
  struct community_entry *entry = NULL;

  if (! list || !ecom )
     return COMMUNITY_NO_MATCH;

  for (entry = list->head; entry; entry = entry->next)
    {
      if (entry->any)
        return entry->direct;

      if (entry->style == EXTCOMMUNITY_LIST_STANDARD)
        {
          if (ecommunity_cmp (ecom, entry->u.ecom))
            return entry->direct;
        }
      else if (entry->style == EXTCOMMUNITY_LIST_EXPANDED)
        {
          if (ecommunity_regexp_match (ecom, entry->reg))
            return entry->direct;
        }
    }
 return COMMUNITY_NO_MATCH;
}          

/***************************************************************************
 * Function       : ecommunity_list_match                                  *
 * Description    : This funcition will match given extended community     * 
 *                  in community list.                                     * 
 * Input :                                                                 *
 *    ecom         : Extended community                                    *
 *    list         : community list                                        *
 * output :                                                                *
 * community_type  : return permit or deny                                 *
 *                                                                         *  
 ***************************************************************************/

enum community_type
ecommunity_list_match (struct ecommunity *ecom,
                       struct community_list *list)
{
  struct community_entry *entry = NULL;

  if (! list || !ecom )
     return COMMUNITY_NO_MATCH;

  for (entry = list->head; entry; entry = entry->next)
    {
      if (entry->any)
        return entry->direct;

      if (entry->style == EXTCOMMUNITY_LIST_STANDARD)
        {
          if (ecommunity_match (ecom, entry->u.ecom))
            return entry->direct;
        }
      else if (entry->style == EXTCOMMUNITY_LIST_EXPANDED)
        {
          if (ecommunity_regexp_match (ecom, entry->reg))
            return entry->direct;
        }
    }
 return COMMUNITY_NO_MATCH;
}          
